"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
function getName(a) {
    return a.name;
}
var a = {
    name: '',
    age: 0,
};
getName(a);
var p = {
    name: '',
    age: 1,
    gender: 0
};
getName(p); // Person中包含Animal 所以可以这样操作
// 基本属性类型的兼容性
var num;
var str = '';
num = str;
var num2 = {
    toString: function () { }
};
num2 = str;
// 错误 str = num2
var e;
(function (e) {
    // 类的兼容性
    var Animal = /** @class */ (function () {
        function Animal() {
        }
        return Animal;
    }());
    var Bird = /** @class */ (function (_super) {
        __extends(Bird, _super);
        function Bird() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        return Bird;
    }(Animal));
    var a = {
        name: 'bl'
    };
    var b = {
        name: 'bl',
        age: 19
    };
    // 如果 两个类都是空的  可以互相赋值
    a = b;
    // b = a // 如果添加了具体属性 子类中包含父类中没有的属性  则不能赋值
})(e || (e = {}));
var sum;
function f1(a, b) {
}
sum = f1;
function f2(a) {
}
sum = f2; // 参数少了也可以
function f3() {
}
sum = f2; // 没有参数也可以
function f4(a, b, c) {
}
var getPerson;
function g1() {
    return { name: 'smd', age: 18 };
}
getPerson = g1;
function g2() {
    return { name: 'smd', age: 18, spk: '123' };
}
getPerson = g2;
function g3() {
    return { name: 'smd' };
}
// getPerson = g3 不可以  返回值必须大于规定的类型 因为取值后进行操作时可能会报错 
var c;
(function (c) {
    /**
     * 返回值类型是协变的   参数类型是逆变的
     *
     * 返回值类型可以传子类,参数可以传父类
     * 参数逆变父类 返回值协变子类
     */
    var Animal = /** @class */ (function () {
        function Animal() {
        }
        return Animal;
    }());
    var Dog = /** @class */ (function (_super) {
        __extends(Dog, _super);
        function Dog() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.name = 'Dog';
            return _this;
        }
        return Dog;
    }(Animal));
    var BlackDog = /** @class */ (function (_super) {
        __extends(BlackDog, _super);
        function BlackDog() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.age = 10;
            return _this;
        }
        return BlackDog;
    }(Dog));
    var WhiteDog = /** @class */ (function (_super) {
        __extends(WhiteDog, _super);
        function WhiteDog() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.home = 'bj';
            return _this;
        }
        return WhiteDog;
    }(Dog));
    var animal;
    var dog;
    var blackDog;
    var whiteDog;
    function exec(callback) {
        // 错误 callback(animal)
        callback(dog);
        callback(blackDog);
        callback(whiteDog);
    }
    /**
     * tsconfig中
     *  "strictFunctionTypes": true // 函数的 协变与逆变   为true时 参数不能多传  为false时，不校验
     */
})(c || (c = {}));
var x = 'smd'; // { data: string }
var y = 123; // { data: number }
x = y; // 当Empty中没有属性时可以，但如果存在属性后则不能互相赋值
var d;
(function (d) {
    // 枚举的兼容性  数字和枚举是兼容的
    var Colors;
    (function (Colors) {
        Colors[Colors["Red"] = 0] = "Red";
        Colors[Colors["Yellow"] = 1] = "Yellow";
    })(Colors || (Colors = {}));
    var c;
    c = Colors.Red;
    c = 1;
    var n = 100;
    n = c;
    c = n;
})(d || (d = {}));
